<!DOCTYPE html>
<html lang="en" dir="ltr" class="client-nojs">
<head>
<title>Member access operators - cppreference.com</title>
<meta charset="UTF-8">
<meta name="generator" content="MediaWiki 1.21.2">
<link rel="shortcut icon" href="../../../common/favicon.ico">
<link rel="stylesheet" href="../../../common/ext.css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link rel="stylesheet" href="../../../common/site_modules.css">
<style>a:lang(ar),a:lang(ckb),a:lang(fa),a:lang(kk-arab),a:lang(mzn),a:lang(ps),a:lang(ur){text-decoration:none}#toc{display:none}.editsection{display:none}
/* cache key: mwiki1-mwiki_en_:resourceloader:filter:minify-css:7:472787eddcf4605d11de8c7ef047234f */</style>

<script src="../../../common/startup_scripts.js"></script>
<script>if(window.mw){
mw.config.set({"wgCanonicalNamespace":"","wgCanonicalSpecialPageName":false,"wgNamespaceNumber":0,"wgPageName":"cpp/language/operator_member_access","wgTitle":"cpp/language/operator member access","wgCurRevisionId":140248,"wgArticleId":707,"wgIsArticle":true,"wgAction":"view","wgUserName":null,"wgUserGroups":["*"],"wgCategories":[],"wgBreakFrames":false,"wgPageContentLanguage":"en","wgSeparatorTransformTable":["",""],"wgDigitTransformTable":["",""],"wgDefaultDateFormat":"dmy","wgMonthNames":["","January","February","March","April","May","June","July","August","September","October","November","December"],"wgMonthNamesShort":["","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],"wgRelevantPageName":"cpp/language/operator_member_access","wgRestrictionEdit":[],"wgRestrictionMove":[]});
}</script><script>if(window.mw){
mw.loader.implement("user.options",function(){mw.user.options.set({"ccmeonemails":0,"cols":80,"date":"default","diffonly":0,"disablemail":0,"disablesuggest":0,"editfont":"default","editondblclick":0,"editsection":0,"editsectiononrightclick":0,"enotifminoredits":0,"enotifrevealaddr":0,"enotifusertalkpages":1,"enotifwatchlistpages":0,"extendwatchlist":0,"externaldiff":0,"externaleditor":0,"fancysig":0,"forceeditsummary":0,"gender":"unknown","hideminor":0,"hidepatrolled":0,"imagesize":2,"justify":0,"math":1,"minordefault":0,"newpageshidepatrolled":0,"nocache":0,"noconvertlink":0,"norollbackdiff":0,"numberheadings":0,"previewonfirst":0,"previewontop":1,"quickbar":5,"rcdays":7,"rclimit":50,"rememberpassword":0,"rows":25,"searchlimit":20,"showhiddencats":0,"showjumplinks":1,"shownumberswatching":1,"showtoc":0,"showtoolbar":1,"skin":"cppreference2","stubthreshold":0,"thumbsize":2,"underline":2,"uselivepreview":0,"usenewrc":0,"watchcreations":0,"watchdefault":0,"watchdeletion":0,
"watchlistdays":3,"watchlisthideanons":0,"watchlisthidebots":0,"watchlisthideliu":0,"watchlisthideminor":0,"watchlisthideown":0,"watchlisthidepatrolled":0,"watchmoves":0,"wllimit":250,"variant":"en","language":"en","searchNs0":true,"searchNs1":false,"searchNs2":false,"searchNs3":false,"searchNs4":false,"searchNs5":false,"searchNs6":false,"searchNs7":false,"searchNs8":false,"searchNs9":false,"searchNs10":false,"searchNs11":false,"searchNs12":false,"searchNs13":false,"searchNs14":false,"searchNs15":false,"gadget-ColiruCompiler":1,"gadget-MathJax":1});;},{},{});mw.loader.implement("user.tokens",function(){mw.user.tokens.set({"editToken":"+\\","patrolToken":false,"watchToken":false});;},{},{});
/* cache key: mwiki1-mwiki_en_:resourceloader:filter:minify-js:7:9f05c6caceb9bb1a482b6cebd4c5a330 */
}</script>
<script>if(window.mw){
mw.loader.load(["mediawiki.page.startup","mediawiki.legacy.wikibits","mediawiki.legacy.ajax"]);
}</script>
<style type="text/css">/*<![CDATA[*/
.source-cpp {line-height: normal;}
.source-cpp li, .source-cpp pre {
	line-height: normal; border: 0px none white;
}
/**
 * GeSHi Dynamically Generated Stylesheet
 * --------------------------------------
 * Dynamically generated stylesheet for cpp
 * CSS class: source-cpp, CSS id: 
 * GeSHi (C) 2004 - 2007 Nigel McNie, 2007 - 2008 Benny Baumann
 * (http://qbnz.com/highlighter/ and http://geshi.org/)
 * --------------------------------------
 */
.cpp.source-cpp .de1, .cpp.source-cpp .de2 {font: normal normal 1em/1.2em monospace; margin:0; padding:0; background:none; vertical-align:top;}
.cpp.source-cpp  {font-family:monospace;}
.cpp.source-cpp .imp {font-weight: bold; color: red;}
.cpp.source-cpp li, .cpp.source-cpp .li1 {font-weight: normal; vertical-align:top;}
.cpp.source-cpp .ln {width:1px;text-align:right;margin:0;padding:0 2px;vertical-align:top;}
.cpp.source-cpp .li2 {font-weight: bold; vertical-align:top;}
.cpp.source-cpp .kw1 {color: #0000dd;}
.cpp.source-cpp .kw2 {color: #0000ff;}
.cpp.source-cpp .kw3 {color: #0000dd;}
.cpp.source-cpp .kw4 {color: #0000ff;}
.cpp.source-cpp .co1 {color: #909090;}
.cpp.source-cpp .co2 {color: #339900;}
.cpp.source-cpp .coMULTI {color: #ff0000; font-style: italic;}
.cpp.source-cpp .es0 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es1 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es2 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es3 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es4 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es5 {color: #008000; font-weight: bold;}
.cpp.source-cpp .br0 {color: #008000;}
.cpp.source-cpp .sy0 {color: #008000;}
.cpp.source-cpp .sy1 {color: #000080;}
.cpp.source-cpp .sy2 {color: #000040;}
.cpp.source-cpp .sy3 {color: #000040;}
.cpp.source-cpp .sy4 {color: #008080;}
.cpp.source-cpp .st0 {color: #008000;}
.cpp.source-cpp .nu0 {color: #000080;}
.cpp.source-cpp .nu6 {color: #000080;}
.cpp.source-cpp .nu8 {color: #000080;}
.cpp.source-cpp .nu12 {color: #000080;}
.cpp.source-cpp .nu16 {color:#000080;}
.cpp.source-cpp .nu17 {color:#000080;}
.cpp.source-cpp .nu18 {color:#000080;}
.cpp.source-cpp .nu19 {color:#000080;}
.cpp.source-cpp .ln-xtra, .cpp.source-cpp li.ln-xtra, .cpp.source-cpp div.ln-xtra {background-color: #ffc;}
.cpp.source-cpp span.xtra { display:block; }

/*]]>*/
</style><style type="text/css">/*<![CDATA[*/
.source-text {line-height: normal;}
.source-text li, .source-text pre {
	line-height: normal; border: 0px none white;
}
/**
 * GeSHi Dynamically Generated Stylesheet
 * --------------------------------------
 * Dynamically generated stylesheet for text
 * CSS class: source-text, CSS id: 
 * GeSHi (C) 2004 - 2007 Nigel McNie, 2007 - 2008 Benny Baumann
 * (http://qbnz.com/highlighter/ and http://geshi.org/)
 * --------------------------------------
 */
.text.source-text .de1, .text.source-text .de2 {font: normal normal 1em/1.2em monospace; margin:0; padding:0; background:none; vertical-align:top;}
.text.source-text  {font-family:monospace;}
.text.source-text .imp {font-weight: bold; color: red;}
.text.source-text li, .text.source-text .li1 {font-weight: normal; vertical-align:top;}
.text.source-text .ln {width:1px;text-align:right;margin:0;padding:0 2px;vertical-align:top;}
.text.source-text .li2 {font-weight: bold; vertical-align:top;}
.text.source-text .ln-xtra, .text.source-text li.ln-xtra, .text.source-text div.ln-xtra {background-color: #ffc;}
.text.source-text span.xtra { display:block; }

/*]]>*/
</style><!--[if lt IE 7]><style type="text/css">body{behavior:url("/mwiki/skins/cppreference2/csshover.min.htc")}</style><![endif]--></head>
<body class="mediawiki ltr sitedir-ltr ns-0 ns-subject page-cpp_language_operator_member_access skin-cppreference2 action-view cpp-navbar">
        <!-- header -->
        <!-- /header -->
        <!-- content -->
<div id="cpp-content-base">
            <div id="content">
                <a id="top"></a>
                <div id="mw-js-message" style="display:none;"></div>
                                <!-- firstHeading -->
<h1 id="firstHeading" class="firstHeading">Member access operators</h1>
                <!-- /firstHeading -->
                <!-- bodyContent -->
                <div id="bodyContent">
                                        <!-- tagline -->
                    <div id="siteSub">From cppreference.com</div>
                    <!-- /tagline -->
                                        <!-- subtitle -->
                    <div id="contentSub"><span class="subpages">&lt; <a href="../../cpp.html" title="cpp">cpp</a>‎ | <a href="../language.html" title="cpp/language">language</a></span></div>
                    <!-- /subtitle -->
                                                            <!-- bodycontent -->
                    <div id="mw-content-text" lang="en" dir="ltr" class="mw-content-ltr"><div class="t-navbar" style=""><div class="t-navbar-sep"> </div><div class="t-navbar-head"><a href="../../cpp.html" title="cpp"> C++</a><div class="t-navbar-menu"><div><div><table class="t-nv-begin" cellpadding="0" style="line-height:1.1em;">
<tr class="t-nv"><td colspan="5"> <a href="../compiler_support.html" title="cpp/compiler support"> Compiler support</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../freestanding.html" title="cpp/freestanding"> Freestanding and hosted</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../language.html" title="cpp/language"> Language</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../header.html" title="cpp/header"> Standard library headers</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../named_req.html" title="cpp/named req"> Named requirements </a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../feature_test.html" title="cpp/feature test"> Feature test macros </a> <span class="t-mark-rev t-since-cxx20">(C++20)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../utility.html#Language_support" title="cpp/utility"> Language support library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../concepts.html" title="cpp/concepts"> Concepts library</a> <span class="t-mark-rev t-since-cxx20">(C++20)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../meta.html" title="cpp/meta"> Metaprogramming library</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../error.html" title="cpp/error"> Diagnostics library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../utility.html" title="cpp/utility"> General utilities library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../string.html" title="cpp/string"> Strings library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../container.html" title="cpp/container"> Containers library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../iterator.html" title="cpp/iterator"> Iterators library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../ranges.html" title="cpp/ranges"> Ranges library</a> <span class="t-mark-rev t-since-cxx20">(C++20)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../algorithm.html" title="cpp/algorithm"> Algorithms library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../numeric.html" title="cpp/numeric"> Numerics library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../locale.html" title="cpp/locale"> Localizations library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../io.html" title="cpp/io"> Input/output library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../filesystem.html" title="cpp/filesystem"> Filesystem library</a> <span class="t-mark-rev t-since-cxx17">(C++17)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../regex.html" title="cpp/regex"> Regular expressions library</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../thread.html" title="cpp/thread"> Concurrency support library</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../experimental.html" title="cpp/experimental"> Technical specifications</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../symbol_index.html" title="cpp/symbol index"> Symbols index</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../links/libs.html" title="cpp/links/libs"> External libraries</a> </td></tr>
</table></div><div></div></div></div></div><div class="t-navbar-sep"> </div><div class="t-navbar-head"><a href="../language.html" title="cpp/language"> C++ language</a><div class="t-navbar-menu"><div><div style="display:inline-block">
<div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv-h1"><td colspan="5"> General topics</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="../preprocessor.html" title="cpp/preprocessor"> Preprocessor</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../comments.html" title="cpp/comment"> Comments</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="../keywords.html" title="cpp/keyword"> Keywords</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="escape.html" title="cpp/language/escape"> Escape sequences</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"> <a href="statements.html" title="cpp/language/statements"> Flow control</a></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Conditional execution statements</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="if.html" title="cpp/language/if"><tt>if</tt></a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="switch.html" title="cpp/language/switch"><tt>switch</tt></a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Iteration statements (loops)</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="for.html" title="cpp/language/for"><tt>for</tt></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="range-for.html" title="cpp/language/range-for"> range-<code>for</code></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="while.html" title="cpp/language/while"><tt>while</tt></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="do.html" title="cpp/language/do"> <code>do-while</code></a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Jump statements </td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="continue.html" title="cpp/language/continue"><tt>continue</tt></a> - <a href="break.html" title="cpp/language/break"><tt>break</tt></a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="goto.html" title="cpp/language/goto"><tt>goto</tt></a> - <a href="return.html" title="cpp/language/return"><tt>return</tt></a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"> <a href="functions.html" title="cpp/language/functions"> Functions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="function.html" title="cpp/language/function"> Function declaration</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="lambda.html" title="cpp/language/lambda"> Lambda function expression</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="inline.html" title="cpp/language/inline"> <code>inline</code> specifier</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="except_spec.html" title="cpp/language/except spec"> Dynamic exception specifications</a> <span class="t-mark-rev t-until-cxx20">(until C++20)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="noexcept_spec.html" title="cpp/language/noexcept spec"> <code>noexcept</code> specifier</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv-h1"><td colspan="5"> Exceptions</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="throw.html" title="cpp/language/throw"> <code>throw</code>-expression</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="try_catch.html" title="cpp/language/try catch"> <code>try</code>-<code>catch</code> block</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"> Namespaces</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="namespace.html" title="cpp/language/namespace"> Namespace declaration</a>  </td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="namespace_alias.html" title="cpp/language/namespace alias"> Namespace aliases</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"> Types</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="types.html" title="cpp/language/types"> Fundamental types</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="enum_class.html" title="cpp/language/enum"> Enumeration types</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="function.html" title="cpp/language/function"> Function types</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="class.html" title="cpp/language/class"> Class/struct types</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="union.html" title="cpp/language/union"> Union types</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Specifiers</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="decltype.html" title="cpp/language/decltype"><tt>decltype</tt></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="auto.html" title="cpp/language/auto"><tt>auto</tt></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="alignas.html" title="cpp/language/alignas"><tt>alignas</tt></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="cv.html" title="cpp/language/cv"> <code>const</code>/<code>volatile</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="constexpr.html" title="cpp/language/constexpr"><tt>constexpr</tt></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
</table></div></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="storage_duration.html" title="cpp/language/storage duration"> Storage duration specifiers</a></td></tr>
<tr class="t-nv-h2"><td colspan="5"> <a href="initialization.html" title="cpp/language/initialization"> Initialization</a></td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="default_initialization.html" title="cpp/language/default initialization"> Default initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="value_initialization.html" title="cpp/language/value initialization"> Value initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="zero_initialization.html" title="cpp/language/zero initialization"> Zero initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="copy_initialization.html" title="cpp/language/copy initialization"> Copy initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="direct_initialization.html" title="cpp/language/direct initialization"> Direct initialization</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="aggregate_initialization.html" title="cpp/language/aggregate initialization"> Aggregate initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="list_initialization.html" title="cpp/language/list initialization"> List initialization</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="constant_initialization.html" title="cpp/language/constant initialization"> Constant initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="reference_initialization.html" title="cpp/language/reference initialization"> Reference initialization</a></td></tr>
</table></div></td></tr>
</table></div>
</div>
<div style="display:inline-block">
<div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv-h1"><td colspan="5"> <a href="expressions.html" title="cpp/language/expressions"> Expressions</a></td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="value_category.html" title="cpp/language/value category"> Value categories</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="eval_order.html" title="cpp/language/eval order"> Order of evaluation</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="operators.html" title="cpp/language/operators"> Operators</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_precedence.html" title="cpp/language/operator precedence"> Operator precedence</a></td></tr>
</table></div></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_alternative.html" title="cpp/language/operator alternative"> Alternative representations</a></td></tr>
<tr class="t-nv-h2"><td colspan="5"> <a href="expressions.html#Literals" title="cpp/language/expressions"> Literals</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="bool_literal.html" title="cpp/language/bool literal"> Boolean</a> - <a href="integer_literal.html" title="cpp/language/integer literal"> Integer</a> - <a href="floating_literal.html" title="cpp/language/floating literal"> Floating-point</a></td></tr>   
<tr class="t-nv"><td colspan="5"> <a href="character_literal.html" title="cpp/language/character literal"> Character</a> - <a href="string_literal.html" title="cpp/language/string literal"> String</a> - <a href="nullptr.html" title="cpp/language/nullptr"><tt>nullptr</tt></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr> 
<tr class="t-nv"><td colspan="5"> <a href="user_literal.html" title="cpp/language/user literal"> User-defined</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv-h1"><td colspan="5"> Utilities</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="attributes.html" title="cpp/language/attributes"> Attributes</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Types</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="typedef.html" title="cpp/language/typedef"> <code>typedef</code> declaration</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="type_alias.html" title="cpp/language/type alias"> Type alias declaration</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Casts</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="implicit_cast.html" title="cpp/language/implicit conversion"> Implicit conversions</a> - <a href="explicit_cast.html" title="cpp/language/explicit cast"> Explicit conversions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="static_cast.html" title="cpp/language/static cast"><tt>static_cast</tt></a> - <a href="dynamic_cast.html" title="cpp/language/dynamic cast"><tt>dynamic_cast</tt></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="const_cast.html" title="cpp/language/const cast"><tt>const_cast</tt></a> - <a href="reinterpret_cast.html" title="cpp/language/reinterpret cast"><tt>reinterpret_cast</tt></a></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Memory allocation</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="new.html" title="cpp/language/new"> <code>new</code> expression</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="delete.html" title="cpp/language/delete"> <code>delete</code> expression</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"> <a href="classes.html" title="cpp/language/classes"> Classes</a></td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="class.html" title="cpp/language/class"> Class declaration</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="initializer_list.html" title="cpp/language/constructor"> Constructors</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="this.html" title="cpp/language/this"> <code>this</code> pointer</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="access.html" title="cpp/language/access"> Access specifiers</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="friend.html" title="cpp/language/friend"> <code>friend</code> specifier</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Class-specific function properties</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="virtual.html" title="cpp/language/virtual"> Virtual function</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="override.html" title="cpp/language/override"> <code>override</code> specifier</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="final.html" title="cpp/language/final"> <code>final</code> specifier</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="explicit.html" title="cpp/language/explicit"><tt>explicit</tt></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="static.html" title="cpp/language/static"><tt>static</tt></a> </td></tr>
</table></div></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Special member functions</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="default_constructor.html" title="cpp/language/default constructor"> Default constructor</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="copy_constructor.html" title="cpp/language/copy constructor"> Copy constructor</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="move_constructor.html" title="cpp/language/move constructor"> Move constructor</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="as_operator.html" title="cpp/language/as operator" class="mw-redirect"> Copy assignment</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="move_operator.html" title="cpp/language/move operator" class="mw-redirect"> Move assignment</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="destructor.html" title="cpp/language/destructor"> Destructor</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"><a href="templates.html" title="cpp/language/templates"> Templates</a> </td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="class_template.html" title="cpp/language/class template"> Class template </a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="function_template.html" title="cpp/language/function template"> Function template </a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="template_specialization.html" title="cpp/language/template specialization"> Template specialization</a></td></tr>   
<tr class="t-nv"><td colspan="5"> <a href="parameter_pack.html" title="cpp/language/parameter pack"> Parameter packs</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"> Miscellaneous </td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="asm.html" title="cpp/language/asm"> Inline assembly</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="history.html" title="cpp/language/history"> History of C++</a></td></tr>
</table></div></td></tr>
</table></div>
</div><div></div></div></div></div><div class="t-navbar-sep"> </div><div class="t-navbar-head"><a href="expressions.html" title="cpp/language/expressions"> Expressions</a><div class="t-navbar-menu"><div><div style="display:inline-block">
<div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv-h2"><td colspan="5"> General </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="value_category.html" title="cpp/language/value category"> value categories</a> (lvalue, rvalue, xvalue)</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="eval_order.html" title="cpp/language/eval order"> order of evaluation</a> (sequence points)</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="constant_expression.html" title="cpp/language/constant expression"> constant expressions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="expressions.html#Unevaluated_expressions" title="cpp/language/expressions"> unevaluated expressions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="expressions.html#Primary_expressions" title="cpp/language/expressions"> primary expressions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="lambda.html" title="cpp/language/lambda">lambda-expression</a><span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Literals </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="integer_literal.html" title="cpp/language/integer literal">integer literals</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="floating_literal.html" title="cpp/language/floating literal">floating-point literals</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="bool_literal.html" title="cpp/language/bool literal">boolean literals</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="character_literal.html" title="cpp/language/character literal">character literals</a> including <a href="escape.html" title="cpp/language/escape">escape sequences</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="string_literal.html" title="cpp/language/string literal">string literals</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="nullptr.html" title="cpp/language/nullptr">null pointer literal</a><span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="user_literal.html" title="cpp/language/user literal">user-defined literal</a><span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Operators </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_assignment.html" title="cpp/language/operator assignment"> Assignment operators</a>: 
<code>a=b</code>, <code>a+=b</code>, <code>a-=b</code>, <code>a*=b</code>, <code>a/=b</code>, <code>a%=b</code>, <code>a&amp;=b</code>, <code>a|=b</code>, <code>a^=b</code>, <code>a&lt;&lt;=b</code>, <code>a&gt;&gt;=b</code></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_incdec.html" title="cpp/language/operator incdec"> Increment and decrement</a>: <code>++a</code>, <code>--a</code>, <code>a++</code>, <code>a--</code></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_arithmetic.html" title="cpp/language/operator arithmetic"> Arithmetic operators</a>:
<code>+a</code>, <code>-a</code>, <code>a+b</code>, <code>a-b</code>, <code>a*b</code>, <code>a/b</code>, <code>a%b</code>, <code>~a</code>, <code>a&amp;b</code>, <code>a|b</code>, <code>a^b</code>, <code>a&lt;&lt;b</code>, <code>a&gt;&gt;b</code> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_logical.html" title="cpp/language/operator logical"> Logical operators</a>: <code>a||b</code>, <code>a&amp;&amp;b</code>, <code>!a</code></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_comparison.html" title="cpp/language/operator comparison"> Comparison operators</a>: <code>a==b</code>, <code>a!=b</code>, <code>a&lt;b</code>, <code>a&gt;b</code>, <code>a&lt;=b</code>, <code>a&gt;=b</code>, <code>a&lt;=&gt;b</code><span class="t-mark-rev t-since-cxx20">(C++20)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <strong class="selflink"> Member access operators</strong>: <code>a[b]</code>, <code>*a</code>, <code>&amp;a</code>, <code>a-&gt;b</code>, <code>a.b</code>, <code>a-&gt;*b</code>, <code>a.*b</code></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_other.html" title="cpp/language/operator other"> Other operators</a>: <code>a(...)</code>, <code>a,b</code>, <code>a?b:c</code> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="new.html" title="cpp/language/new">new-expression</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="delete.html" title="cpp/language/delete">delete-expression</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="throw.html" title="cpp/language/throw">throw-expression</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="alignof.html" title="cpp/language/alignof"><code>alignof</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="sizeof.html" title="cpp/language/sizeof"><code>sizeof</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="sizeof....html" title="cpp/language/sizeof..."><code>sizeof...</code></a><span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="typeid.html" title="cpp/language/typeid"><code>typeid</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="noexcept.html" title="cpp/language/noexcept"><code>noexcept</code></a><span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="fold.html" title="cpp/language/fold">Fold expression</a><span class="t-mark-rev t-since-cxx17">(C++17)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_alternative.html" title="cpp/language/operator alternative">Alternative representations of operators</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_precedence.html" title="cpp/language/operator precedence">Precedence and associativity</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operators.html" title="cpp/language/operators">Operator overloading</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="default_comparisons.html" title="cpp/language/default comparisons">Default comparisons</a><span class="t-mark-rev t-since-cxx20">(C++20)</span></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Conversions </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="implicit_cast.html" title="cpp/language/implicit conversion">Implicit conversions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="const_cast.html" title="cpp/language/const cast"><code>const_cast</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="static_cast.html" title="cpp/language/static cast"><code>static_cast</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="reinterpret_cast.html" title="cpp/language/reinterpret cast"><code>reinterpret_cast</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="dynamic_cast.html" title="cpp/language/dynamic cast"><code>dynamic_cast</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="explicit_cast.html" title="cpp/language/explicit cast">Explicit conversions</a> <code>(T)a</code>, <code>T(a)</code></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="cast_operator.html" title="cpp/language/cast operator">User-defined conversion</a></td></tr>
</table></div>
</div><div></div></div></div></div><div class="t-navbar-sep"> </div></div>
<p>Accesses a member of its operand.
</p>
<table class="wikitable" style="font-size:85%;">

<tr>
<th rowspan="2"> Operator name
</th>
<th rowspan="2"> Syntax
</th>
<th rowspan="2"> <a href="operators.html" title="cpp/language/operators">Over​load​able</a>
</th>
<th colspan="2"> Prototype examples (for <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw1">class</span> T</span></span>)
</th></tr>
<tr>
<th> Inside class definition
</th>
<th> Outside class definition
</th></tr>
<tr>
<td> subscript
</td>
<td> <code>a[b]</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy3">&amp;</span> T<span class="sy4">::</span><span class="me2">operator</span><span class="br0">[</span><span class="br0">]</span><span class="br0">(</span>S b<span class="br0">)</span><span class="sy4">;</span></span></span> <table class="t-rev-begin">
<tr class="t-rev t-since-cxx23"><td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy3">&amp;</span> T<span class="sy4">::</span><span class="me2">operator</span><span class="br0">[</span><span class="br0">]</span><span class="br0">(</span>S1 s1, ...<span class="br0">)</span><span class="sy4">;</span></span></span>
</p>
</td>
<td><span class="t-mark-rev t-since-cxx23">(since C++23)</span></td></tr>
</table>
</td>
<td style="background: #ececec; color: grey; vertical-align: middle; text-align: center;" class="table-na"> <small>N/A</small>
</td></tr>
<tr>
<td> indirection
</td>
<td> <code>*a</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy3">&amp;</span> T<span class="sy4">::</span><span class="me2">operator</span><span class="sy2">*</span><span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span></span></span>
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy3">&amp;</span> operator<span class="sy2">*</span><span class="br0">(</span>T a<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td> address-of
</td>
<td> <code>&amp;a</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy2">*</span> T<span class="sy4">::</span><span class="me2">operator</span><span class="sy3">&amp;</span><span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span></span></span>
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy2">*</span> operator<span class="sy3">&amp;</span><span class="br0">(</span>T a<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td> member of object
</td>
<td> <code>a.b</code>
</td>
<td style="background:#ff9090; color:black; vertical-align: middle; text-align: center;" class="table-no"> No
</td>
<td style="background: #ececec; color: grey; vertical-align: middle; text-align: center;" class="table-na"> <small>N/A</small>
</td>
<td style="background: #ececec; color: grey; vertical-align: middle; text-align: center;" class="table-na"> <small>N/A</small>
</td></tr>
<tr>
<td> member of pointer
</td>
<td> <code>a-&gt;b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy2">*</span> T<span class="sy4">::</span><span class="me2">operator</span><span class="sy2">-</span><span class="sy1">&gt;</span><span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span></span></span>
</td>
<td style="background: #ececec; color: grey; vertical-align: middle; text-align: center;" class="table-na"> <small>N/A</small>
</td></tr>
<tr>
<td> pointer to member of object
</td>
<td> <code>a.*b</code>
</td>
<td style="background:#ff9090; color:black; vertical-align: middle; text-align: center;" class="table-no"> No
</td>
<td style="background: #ececec; color: grey; vertical-align: middle; text-align: center;" class="table-na"> <small>N/A</small>
</td>
<td style="background: #ececec; color: grey; vertical-align: middle; text-align: center;" class="table-na"> <small>N/A</small>
</td></tr>
<tr>
<td> pointer to member of pointer
</td>
<td> <code>a-&gt;*b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy3">&amp;</span> T<span class="sy4">::</span><span class="me2">operator</span><span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span><span class="br0">(</span>S b<span class="br0">)</span><span class="sy4">;</span></span></span>
</td>
<td> <span class="t-c"><span class="mw-geshi cpp source-cpp">R<span class="sy3">&amp;</span> operator<span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span><span class="br0">(</span>T a, S b<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td colspan="5">
<dl><dd><b>Notes</b><br>
</dd></dl>
<ul><li> As with most user-defined overloads, return types should match return types provided by the built-in operators so that <a href="operators.html" title="cpp/language/operators">the user-defined operators</a> can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">void</span></span></span>). One exception is <code>operator-&gt;</code>, which must return a pointer or another class with overloaded <code>operator-&gt;</code> to be realistically usable.
</li></ul>
</td></tr></table>
<h3><span class="mw-headline" id="Explanation">Explanation</span></h3>
<p>Built-in <i>subscript</i> operator provides access to an object pointed-to by the <a href="pointer.html" title="cpp/language/pointer">pointer</a> or <a href="array.html" title="cpp/language/array">array</a> operand.
</p><p>Built-in <i>indirection</i> operator provides access to an object or function pointed-to by the pointer operand.
</p><p>Built-in <i>address-of</i> operator creates a pointer pointing to the object or function operand.
</p><p><i>Member of object</i> and <i>pointer to member of object</i> operators provide access to a data member or member function of the object operand.
</p><p>Built-in <i>member of pointer</i> and <i>pointer to member of pointer</i> operators provide access to a data member or member function of the class pointed-to by the pointer operand.
</p>
<h4><span class="mw-headline" id="Built-in_subscript_operator">Built-in subscript operator</span></h4>
<p>The subscript operator expressions have the form 
</p>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">expr1</span> <code><b>[</b></code> <span class="t-spar">expr2</span> <code><b>]</b></code>
</td>
<td> (1)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">expr1</span> <code><b>[</b></code> <code><b>{</b></code> <span class="t-spar">expr, ...</span> <code><b>}</b></code> <code><b>]</b></code>
</td>
<td> (2)
</td>
<td> <span class="t-mark-rev t-since-cxx11">(C++11)</span>
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">expr1</span> <code><b>[</b></code> <span class="t-spar">expr2</span> <code><b>,</b></code> <span class="t-spar">expr, ...</span> <code><b>]</b></code>
</td>
<td> (3)
</td>
<td> <span class="t-mark-rev t-since-cxx23">(C++23)</span>
</td></tr>

 

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr></table>
<div class="t-li1"><span class="t-li">1)</span> For the built-in operator, one of the expressions (either <span class="t-spar">expr1</span> or <span class="t-spar">expr2</span>) must be a glvalue of type “array of T” or a prvalue of type “pointer to T”, while the other expression (<span class="t-spar">expr2</span> or <span class="t-spar">expr1</span>, respectively) must be a prvalue of unscoped enumeration or integral type. The result of this expression has the type <code>T</code>. <span class="t-rev-inl t-since-cxx23"><span><span class="t-spar">expr2</span> cannot be a unparenthesized <a href="operator_other.html#Built-in_comma_operator" title="cpp/language/operator other">comma expression</a>.</span> <span><span class="t-mark-rev t-since-cxx23">(since C++23)</span></span></span></div>
<div class="t-li1"><span class="t-li">2)</span> The form with brace-enclosed list inside the square brackets is only used to call an overloaded <code>operator[]</code>.</div>
<div class="t-li1"><span class="t-li">3)</span> The form with comma-separated expression list inside the square brackets is only used to call an overloaded <code>operator[]</code>.</div>
<p>The built-in subscript expression <span class="t-c"><span class="mw-geshi cpp source-cpp">E1<span class="br0">[</span>E2<span class="br0">]</span></span></span> is exactly identical to the expression <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy2">*</span><span class="br0">(</span>E1 <span class="sy2">+</span> E2<span class="br0">)</span></span></span><span class="t-rev-inl t-since-cxx17"><span> except <a href="eval_order.html" title="cpp/language/eval order">evaluation order</a></span> <span><span class="t-mark-rev t-since-cxx17">(since C++17)</span></span></span>, that is, the pointer operand (which may be a result of array-to-pointer conversion, and which must point to an element of some array or one past the end) is adjusted to point to another element of the same array, following the rules of <a href="operator_arithmetic.html" title="cpp/language/operator arithmetic">pointer arithmetics</a>, and is then dereferenced.
</p><p>When applied to an array, the subscript expression is an <a href="value_category.html" title="cpp/language/value category">lvalue</a><span class="t-rev-inl t-since-cxx11"><span> if the array is an lvalue, and an <a href="value_category.html" title="cpp/language/value category">xvalue</a> if it isn't</span> <span><span class="t-mark-rev t-since-cxx11">(since C++11)</span></span></span>. 
</p><p>When applied to a pointer, the subscript expression is always an lvalue.
</p><p>The type <code>T</code> is not allowed to be an <a href="incomplete_type.html" title="cpp/language/incomplete type" class="mw-redirect">incomplete type</a>, even if the size or internal structure of <code>T</code> is never used, as in <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">&amp;</span>x<span class="br0">[</span><span class="nu0">0</span><span class="br0">]</span></span></span>.
</p>
 <table class="t-rev-begin">
<tr class="t-rev t-since-cxx20 t-until-cxx23"><td>
<p>Using an unparenthesized <a href="operator_other.html#Built-in_comma_operator" title="cpp/language/operator other">comma expression</a> as second (right) argument of a subscript operator is deprecated.
</p><p>For example, <span class="t-c"><span class="mw-geshi cpp source-cpp">a<span class="br0">[</span>b, c<span class="br0">]</span></span></span> is deprecated and <span class="t-c"><span class="mw-geshi cpp source-cpp">a<span class="br0">[</span><span class="br0">(</span>b, c<span class="br0">)</span><span class="br0">]</span></span></span> is not.
</p>
</td>
<td><span class="t-mark-rev t-since-cxx20">(since C++20)</span><br><span class="t-mark-rev t-until-cxx23">(until C++23)</span></td></tr>
<tr class="t-rev t-since-cxx23"><td>
<p>An unparenthesized <a href="operator_other.html#Built-in_comma_operator" title="cpp/language/operator other">comma expression</a> cannot be second (right) argument of a subscript operator. For example, <span class="t-c"><span class="mw-geshi cpp source-cpp">a<span class="br0">[</span>b, c<span class="br0">]</span></span></span> is either ill-formed or equivalent to <span class="t-c"><span class="mw-geshi cpp source-cpp">a.<span class="me1">operator</span><span class="br0">[</span><span class="br0">]</span><span class="br0">(</span>b, c<span class="br0">)</span></span></span>.
</p><p>Parentheses are needed to for using a comma expression as the subscript, e.g., <span class="t-c"><span class="mw-geshi cpp source-cpp">a<span class="br0">[</span><span class="br0">(</span>b, c<span class="br0">)</span><span class="br0">]</span></span></span>.
</p>
</td>
<td><span class="t-mark-rev t-since-cxx23">(since C++23)</span></td></tr>
</table>
<p>In <a href="overload_resolution.html#Call_to_an_overloaded_operator" title="cpp/language/overload resolution">overload resolution against user-defined operators</a>, for every object type <code>T</code> (possibly cv-qualified), the following function signature participates in overload resolution:
</p>
<table class="t-dcl-begin"><tbody>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">T<span class="sy3">&amp;</span> operator<span class="br0">[</span><span class="br0">]</span><span class="br0">(</span>T<span class="sy2">*</span>, <a href="../types/ptrdiff_t.html"><span class="kw107">std::<span class="me2">ptrdiff_t</span></span></a><span class="br0">)</span><span class="sy4">;</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">T<span class="sy3">&amp;</span> operator<span class="br0">[</span><span class="br0">]</span><span class="br0">(</span><a href="../types/ptrdiff_t.html"><span class="kw107">std::<span class="me2">ptrdiff_t</span></span></a>, T<span class="sy2">*</span><span class="br0">)</span><span class="sy4">;</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl-sep"><td></td><td></td><td></td></tr>
</tbody></table>
<div class="t-example"><div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;iostream&gt;</span>
<span class="co2">#include &lt;string&gt;</span>
<span class="co2">#include &lt;map&gt;</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    <span class="kw4">int</span> a<span class="br0">[</span><span class="nu0">4</span><span class="br0">]</span> <span class="sy1">=</span> <span class="br0">{</span><span class="nu0">1</span>, <span class="nu0">2</span>, <span class="nu0">3</span>, <span class="nu0">4</span><span class="br0">}</span><span class="sy4">;</span>
    <span class="kw4">int</span><span class="sy2">*</span> p <span class="sy1">=</span> <span class="sy3">&amp;</span>a<span class="br0">[</span><span class="nu0">2</span><span class="br0">]</span><span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> p<span class="br0">[</span><span class="nu0">1</span><span class="br0">]</span> <span class="sy1">&lt;&lt;</span> p<span class="br0">[</span><span class="sy2">-</span><span class="nu0">1</span><span class="br0">]</span> <span class="sy1">&lt;&lt;</span> <span class="nu0">1</span><span class="br0">[</span>p<span class="br0">]</span> <span class="sy1">&lt;&lt;</span> <span class="br0">(</span><span class="sy2">-</span><span class="nu0">1</span><span class="br0">)</span><span class="br0">[</span>p<span class="br0">]</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
 
    <a href="../container/map.html"><span class="kw1284">std::<span class="me2">map</span></span></a><span class="sy1">&lt;</span><a href="../utility/pair.html"><span class="kw1099">std::<span class="me2">pair</span></span></a><span class="sy1">&lt;</span><span class="kw4">int</span>, <span class="kw4">int</span><span class="sy1">&gt;</span>, <a href="../string/basic_string.html"><span class="kw1233">std::<span class="me2">string</span></span></a><span class="sy1">&gt;</span> m<span class="sy4">;</span>
    m<span class="br0">[</span><span class="br0">{</span><span class="nu0">1</span>, <span class="nu0">2</span><span class="br0">}</span><span class="br0">]</span> <span class="sy1">=</span> <span class="st0">"abc"</span><span class="sy4">;</span> <span class="co1">// uses the [{...}] version</span>
<span class="br0">}</span></pre></div></div>
<p>Output:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="text source-text"><pre class="de1">4242</pre></div></div> 
</div>
<h4><span class="mw-headline" id="Built-in_indirection_operator">Built-in indirection operator</span></h4>
<p>The indirection operator expressions have the form 
</p>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td class="t-sdsc-nopad"> <code><b>*</b></code> <span class="t-spar">expr</span>
</td>
<td class="t-sdsc-nopad">
</td>
<td class="t-sdsc-nopad">
</td></tr>

 

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr></table>
<p>The operand of the built-in indirection operator must be pointer to object or a pointer to function, and the result is the lvalue referring to the object or function to which <span class="t-spar">expr</span> points.
</p><p>A pointer to (possibly <a href="cv.html" title="cpp/language/cv">cv</a>-qualified) <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">void</span></span></span> cannot be dereferenced. Pointers to other incomplete types can be dereferenced, but the resulting lvalue can only be used in contexts that allow an lvalue of incomplete type, e.g. when initializing a reference. 
</p><p>In <a href="overload_resolution.html#Call_to_an_overloaded_operator" title="cpp/language/overload resolution">overload resolution against user-defined operators</a>, for every type <code>T</code> that is either object type (possibly cv-qualified) or function type (not const- or ref-qualified), the following function signature participates in overload resolution:
</p>
<table class="t-dcl-begin"><tbody>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">T<span class="sy3">&amp;</span> operator<span class="sy2">*</span><span class="br0">(</span>T<span class="sy2">*</span><span class="br0">)</span><span class="sy4">;</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl-sep"><td></td><td></td><td></td></tr>
</tbody></table>
<div class="t-example"><div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;iostream&gt;</span>
 
<span class="kw4">int</span> f<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span> <span class="kw1">return</span> <span class="nu0">42</span><span class="sy4">;</span> <span class="br0">}</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    <span class="kw4">int</span> n <span class="sy1">=</span> <span class="nu0">1</span><span class="sy4">;</span>
    <span class="kw4">int</span><span class="sy2">*</span> pn <span class="sy1">=</span> <span class="sy3">&amp;</span>n<span class="sy4">;</span>
 
    <span class="kw4">int</span><span class="sy3">&amp;</span> r <span class="sy1">=</span> <span class="sy2">*</span>pn<span class="sy4">;</span> <span class="co1">// lvalue can be bound to a reference</span>
    <span class="kw4">int</span> m <span class="sy1">=</span> <span class="sy2">*</span>pn<span class="sy4">;</span>  <span class="co1">// indirection + lvalue-to-rvalue conversion</span>
 
    <span class="kw4">int</span> <span class="br0">(</span><span class="sy2">*</span>fp<span class="br0">)</span><span class="br0">(</span><span class="br0">)</span> <span class="sy1">=</span> <span class="sy3">&amp;</span>f<span class="sy4">;</span>
    <span class="kw4">int</span> <span class="br0">(</span><span class="sy3">&amp;</span>fr<span class="br0">)</span><span class="br0">(</span><span class="br0">)</span> <span class="sy1">=</span> <span class="sy2">*</span>fp<span class="sy4">;</span> <span class="co1">// function lvalue can be bound to a reference </span>
<span class="br0">}</span></pre></div></div>
</div>
<h4><span class="mw-headline" id="Built-in_address-of_operator">Built-in address-of operator</span></h4>
<p>The address-of operator expressions have the form 
</p>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <code><b>&amp;</b></code> <span class="t-spar">expr</span>
</td>
<td> (1)
</td>
<td class="t-sdsc-nopad">
</td></tr>

 

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <code><b>&amp;</b></code> <span class="t-spar">class</span> <code><b>::</b></code> <span class="t-spar">member</span>
</td>
<td> (2)
</td>
<td class="t-sdsc-nopad">
</td></tr>

 

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr></table>
<div class="t-li1"><span class="t-li">1)</span> If the operand is an lvalue expression of some object or function type <code>T</code>, <code>operator&amp;</code> creates and returns a prvalue of type <code>T*</code>, with the same cv qualification, that is pointing to the object or function designated by the operand. If the operand has incomplete type, the pointer can be formed, but if that incomplete type happens to be a class that defines its own <code>operator&amp;</code>, it is unspecified whether the built-in or the overload is used. For the operands of type with user-defined <code>operator&amp;</code>, <span class="t-lc"><a href="../memory/addressof.html" title="cpp/memory/addressof">std::addressof</a></span> may be used to obtain the true pointer.
Note that, unlike C99 and later C versions, there's no special case for the unary <code>operator&amp;</code> applied to the result of the unary <code>operator*</code>.</div>
<div class="t-li1"><span class="t-li"></span> If the operand is the name of an overloaded function, the address may be taken only if the overload can be resolved due to context. See <a href="overloaded_address.html" title="cpp/language/overloaded address">Address of an overloaded function</a> for details.</div>
<div class="t-li1"><span class="t-li">2)</span> If the operand is a qualified name of a non-static or <a href="union.html#Union-like_classes" title="cpp/language/union">variant</a> member, e.g. <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">&amp;</span>C<span class="sy4">::</span><span class="me2">member</span></span></span>, the result is a prvalue <a href="pointer.html#Pointers_to_member_functions" title="cpp/language/pointer">pointer to member function</a> or <a href="pointer.html#Pointers_to_data_members" title="cpp/language/pointer">pointer to data member</a> of type <code>T</code> in class <code>C</code>. Note that neither <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">&amp;</span>member</span></span> nor <span class="t-c"><span class="mw-geshi cpp source-cpp">C<span class="sy4">::</span><span class="me2">member</span></span></span> nor even <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">&amp;</span><span class="br0">(</span>C<span class="sy4">::</span><span class="me2">member</span><span class="br0">)</span></span></span> may be used to initialize a pointer to member.</div>
<p>In <a href="overload_resolution.html#Call_to_an_overloaded_operator" title="cpp/language/overload resolution">overload resolution against user-defined operators</a>, this operator does not introduce any additional function signatures: built-in address-of operator does not apply if there exists an overloaded <code>operator&amp;</code> that is a <a href="overload_resolution.html#Viable_functions" title="cpp/language/overload resolution">viable function</a>.
</p>
<div class="t-example"><div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span>
<span class="kw4">void</span> f<span class="br0">(</span><span class="kw4">double</span><span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span>
 
<span class="kw1">struct</span> A <span class="br0">{</span> <span class="kw4">int</span> i<span class="sy4">;</span> <span class="br0">}</span><span class="sy4">;</span>
<span class="kw1">struct</span> B <span class="br0">{</span> <span class="kw4">void</span> f<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span> <span class="br0">}</span><span class="sy4">;</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    <span class="kw4">int</span> n <span class="sy1">=</span> <span class="nu0">1</span><span class="sy4">;</span>
    <span class="kw4">int</span><span class="sy2">*</span> pn <span class="sy1">=</span> <span class="sy3">&amp;</span>n<span class="sy4">;</span>    <span class="co1">// pointer</span>
    <span class="kw4">int</span><span class="sy2">*</span> pn2 <span class="sy1">=</span> <span class="sy3">&amp;</span><span class="sy2">*</span>pn<span class="sy4">;</span> <span class="co1">// pn2 == pn</span>
 
    <span class="kw4">int</span> A<span class="sy4">::</span><span class="sy2">*</span> mp <span class="sy1">=</span> <span class="sy3">&amp;</span>A<span class="sy4">::</span><span class="me2">i</span><span class="sy4">;</span>      <span class="co1">// pointer to data member</span>
    <span class="kw4">void</span> <span class="br0">(</span>B<span class="sy4">::</span><span class="sy2">*</span>mpf<span class="br0">)</span><span class="br0">(</span><span class="br0">)</span> <span class="sy1">=</span> <span class="sy3">&amp;</span>B<span class="sy4">::</span><span class="me2">f</span><span class="sy4">;</span> <span class="co1">// pointer to member function</span>
 
    <span class="kw4">void</span> <span class="br0">(</span><span class="sy2">*</span>pf<span class="br0">)</span><span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span> <span class="sy1">=</span> <span class="sy3">&amp;</span>f<span class="sy4">;</span> <span class="co1">// overload resolution due to initialization context</span>
<span class="co1">//  auto pf2 = &amp;f; // error: ambiguous overloaded function type</span>
    <span class="kw4">auto</span> pf2 <span class="sy1">=</span> <span class="kw1">static_cast</span><span class="sy1">&lt;</span><span class="kw4">void</span> <span class="br0">(</span><span class="sy2">*</span><span class="br0">)</span><span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span><span class="sy1">&gt;</span><span class="br0">(</span><span class="sy3">&amp;</span>f<span class="br0">)</span><span class="sy4">;</span> <span class="co1">// overload resolution due to cast</span>
<span class="br0">}</span></pre></div></div>
</div>
<h4><span class="mw-headline" id="Built-in_member_access_operators">Built-in member access operators</span></h4>
<p>The member access operator expressions have the form 
</p>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">expr</span> <code><b>.</b></code> <code><b>template</b></code><span class="t-mark">(optional)</span> <span class="t-spar">id-expr</span>
</td>
<td> (1)
</td>
<td class="t-sdsc-nopad">
</td></tr>

 

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">expr</span> <code><b>-&gt;</b></code> <code><b>template</b></code><span class="t-mark">(optional)</span> <span class="t-spar">id-expr</span>
</td>
<td> (2)
</td>
<td class="t-sdsc-nopad">
</td></tr>

 

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">expr</span> <code><b>.</b></code> <span class="t-spar">pseudo-destructor</span>
</td>
<td> (3)
</td>
<td class="t-sdsc-nopad">
</td></tr>

 

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">expr</span> <code><b>-&gt;</b></code> <span class="t-spar">pseudo-destructor</span>
</td>
<td> (4)
</td>
<td class="t-sdsc-nopad">
</td></tr>

 

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr></table>
<div class="t-li1"><span class="t-li">1)</span> The first operand must be an expression of <a href="incomplete_type.html" title="cpp/language/incomplete type" class="mw-redirect">complete class type</a> <code>T</code>.</div>
<div class="t-li1"><span class="t-li">2)</span> The first operand must be an expression of pointer to complete class type <code>T*</code>.</div>
<div class="t-li1"><span class="t-li">3,4)</span> The first operand must be an expression of scalar type (see below)</div>
<p>The first operand of both operators is evaluated even if it is not necessary (e.g. when the second operand names a static member).
</p><p>The second operand of both operators is a name of (formally, an <a href="name.html#In_expressions" title="cpp/language/identifiers">id-expression</a> that names) a data member or member function of <code>T</code> or of an unambiguous and accessible base class <code>B</code> of <code>T</code> (e.g. <span class="t-c"><span class="mw-geshi cpp source-cpp">E1.<span class="me1">E2</span></span></span> or <span class="t-c"><span class="mw-geshi cpp source-cpp">E1<span class="sy2">-</span><span class="sy1">&gt;</span>E2</span></span>), optionally <a href="name.html#Qualified_identifiers" title="cpp/language/identifiers">qualified</a> (e.g. <span class="t-c"><span class="mw-geshi cpp source-cpp">E1.<span class="me1">B</span><span class="sy4">::</span><span class="me2">E2</span></span></span> or <span class="t-c"><span class="mw-geshi cpp source-cpp">E1<span class="sy2">-</span><span class="sy1">&gt;</span>B<span class="sy4">::</span><span class="me2">E2</span></span></span>), optionally using <a href="dependent_name.html#template_disambiguator" title="cpp/language/dependent name"><span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw1">template</span></span></span> disambiguator</a> (e.g. <span class="t-c"><span class="mw-geshi cpp source-cpp">E1.<span class="kw1">template</span> E2</span></span> or <span class="t-c"><span class="mw-geshi cpp source-cpp">E1<span class="sy2">-</span><span class="sy1">&gt;</span><span class="kw1">template</span> E2</span></span>).
</p><p>If a user-defined <code>operator-&gt;</code> is provided, the <code>operator-&gt;</code> is called again on the value that it returns, recursively, until an <code>operator-&gt;</code> is reached that returns a plain pointer. After that, built-in semantics are applied to that pointer.
</p><p>The expression <span class="t-c"><span class="mw-geshi cpp source-cpp">E1<span class="sy2">-</span><span class="sy1">&gt;</span>E2</span></span> is exactly equivalent to <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="br0">(</span><span class="sy2">*</span>E1<span class="br0">)</span>.<span class="me1">E2</span></span></span> for built-in types; that is why the following rules address only <span class="t-c"><span class="mw-geshi cpp source-cpp">E1.<span class="me1">E2</span></span></span>.
</p><p>In the expression <span class="t-c"><span class="mw-geshi cpp source-cpp">E1.<span class="me1">E2</span></span></span>:
</p>
<div class="t-li1"><span class="t-li">1)</span> if <code>E2</code> is a <a href="static.html" title="cpp/language/static">static data member</a>:
<ul><li> if <code>E2</code> is of reference type <code>T&amp;</code> or <code>T&amp;&amp;</code>, the result is an lvalue of type <code>T</code> designating the object or function to which <code>E2</code> refers,
</li><li> otherwise, the result is an lvalue designating that static data member.
</li></ul>
<dl><dd> Essentially, <code>E1</code> is evaluated and discarded in both cases;</dd></dl></div>

<div class="t-li1"><span class="t-li">2)</span> if <code>E2</code> is a <a href="data_members.html" title="cpp/language/data members">non-static data member</a>:
<ul><li> if <code>E2</code> is of reference type <code>T&amp;</code> or <code>T&amp;&amp;</code>, the result is an lvalue of type <code>T</code> designating the object or function to which <code>E2</code> refers,
</li><li> otherwise, if <code>E1</code> is an lvalue, the result is an lvalue designating that non-static data member of <code>E1</code>,
</li><li> otherwise (if <code>E1</code> is an <span class="t-rev-inl t-until-cxx17"><span>rvalue</span> <span><span class="t-mark-rev t-until-cxx17">(until C++17)</span></span></span><span class="t-rev-inl t-since-cxx17"><span>xvalue (which may be <a href="implicit_cast.html#Temporary_materialization" title="cpp/language/implicit conversion">materialized</a> from prvalue)</span> <span><span class="t-mark-rev t-since-cxx17">(since C++17)</span></span></span>), the result is an <span class="t-rev-inl t-until-cxx11"><span>rvalue</span> <span><span class="t-mark-rev t-until-cxx11">(until C++11)</span></span></span><span class="t-rev-inl t-since-cxx11"><span>xvalue</span> <span><span class="t-mark-rev t-since-cxx11">(since C++11)</span></span></span> designating that non-static data member of <code>E1</code>.
</li></ul>
<dl><dd> If <code>E2</code> is not a mutable member, the <a href="cv.html" title="cpp/language/cv">cv-qualification</a> of the result is the union of the cv-qualifications of <code>E1</code> and <code>E2</code>, otherwise (if <code>E2</code> is a mutable member), it is the union of the volatile-qualifications of <code>E1</code> and <code>E2</code>;</dd></dl></div>

<div class="t-li1"><span class="t-li">3)</span> if <code>E2</code> is a <a href="static.html" title="cpp/language/static">static member function</a>, the result is an lvalue designating that static member function. Essentially, <code>E1</code> is evaluated and discarded in this case;</div>
<div class="t-li1"><span class="t-li">4)</span> if <code>E2</code> is a <a href="member_functions.html" title="cpp/language/member functions">non-static member function</a> including a <a href="destructor.html" title="cpp/language/destructor">destructor</a>, the result is a special kind of prvalue designating that non-static member function of <code>E1</code> that can only be used as the left-hand operand of a member function call operator, and for no other purpose;</div>
<div class="t-li1"><span class="t-li">5)</span> if <code>E2</code> is a member enumerator, the result is a prvalue equal to that member enumerator of <code>E1</code>;</div>
<div class="t-li1"><span class="t-li">6)</span> if <code>E2</code> is a <a href="nested_classes.html" title="cpp/language/nested classes" class="mw-redirect">nested type</a>, the program is ill-formed (won't compile);</div>
<div class="t-li1"><span class="t-li">7)</span> if <code>E1</code> has a <a href="type-id.html" title="cpp/language/type">scalar type</a> and <code>E2</code> is a <code><b>~</b></code> followed by the <a href="type-id.html#Type_naming" title="cpp/language/type">type name</a> or <a href="decltype.html" title="cpp/language/decltype">decltype specifier</a> designating the same type (minus cv-qualifications), optionally <a href="name.html#Qualified_identifiers" title="cpp/language/identifiers">qualified</a>, the result is a special kind of prvalue that can only be used as the left-hand operand of a function call operator, and for no other purpose. The resulting function call expression is called <i>pseudo destructor call</i>. It takes no arguments, returns void, evaluates <code>E1</code>, and ends the lifetime of its result object. This is the only case where the left-hand operand of <code>operator.</code> has non-class type. Allowing pseudo destructor call makes it possible to write code without having to know if a destructor exists for a given type.</div>
<p><code>operator.</code> cannot be overloaded, and for <code>operator-&gt;</code>, in <a href="overload_resolution.html#Call_to_an_overloaded_operator" title="cpp/language/overload resolution">overload resolution against user-defined operators</a>, the built-in operator does not introduce any additional function signatures: built-in <code>operator-&gt;</code> does not apply if there exists an overloaded <code>operator-&gt;</code> that is a <a href="overload_resolution.html#Viable_functions" title="cpp/language/overload resolution">viable function</a>.
</p>
<div class="t-example"><div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;iostream&gt;</span>
 
<span class="kw1">struct</span> P
<span class="br0">{</span>
    <span class="kw1">template</span><span class="sy1">&lt;</span><span class="kw1">typename</span> T<span class="sy1">&gt;</span>
    <span class="kw4">static</span> T<span class="sy2">*</span> ptr<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span> <span class="kw1">return</span> new T<span class="sy4">;</span> <span class="br0">}</span>
<span class="br0">}</span><span class="sy4">;</span>
 
<span class="kw1">template</span><span class="sy1">&lt;</span><span class="kw1">typename</span> T<span class="sy1">&gt;</span>
<span class="kw1">struct</span> A
<span class="br0">{</span>
    A<span class="br0">(</span><span class="kw4">int</span> n<span class="br0">)</span><span class="sy4">:</span> n<span class="br0">(</span>n<span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span>
 
    <span class="kw4">int</span> n<span class="sy4">;</span>
    <span class="kw4">static</span> <span class="kw4">int</span> sn<span class="sy4">;</span>
 
    <span class="kw4">int</span> f<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span> <span class="kw1">return</span> <span class="nu0">10</span> <span class="sy2">+</span> n<span class="sy4">;</span> <span class="br0">}</span>
    <span class="kw4">static</span> <span class="kw4">int</span> sf<span class="br0">(</span><span class="br0">)</span> <span class="br0">{</span> <span class="kw1">return</span> <span class="nu0">4</span><span class="sy4">;</span> <span class="br0">}</span>
 
    <span class="kw1">class</span> B <span class="br0">{</span><span class="br0">}</span><span class="sy4">;</span>
    <span class="kw2">enum</span> E <span class="br0">{</span>RED <span class="sy1">=</span> <span class="nu0">1</span>, BLUE <span class="sy1">=</span> <span class="nu0">2</span><span class="br0">}</span><span class="sy4">;</span>
 
    <span class="kw4">void</span> g<span class="br0">(</span><span class="br0">)</span>
    <span class="br0">{</span>
        <span class="kw1">typedef</span> <span class="kw4">int</span> U<span class="sy4">;</span>
 
        <span class="co1">// keyword template needed for a dependent template member</span>
        <span class="kw4">int</span><span class="sy2">*</span> p <span class="sy1">=</span> T<span class="br0">(</span><span class="br0">)</span>.<span class="kw1">template</span> ptr<span class="sy1">&lt;</span>U<span class="sy1">&gt;</span><span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span>
        p<span class="sy2">-</span><span class="sy1">&gt;</span>~U<span class="br0">(</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// U is int, calls int's pseudo destructor</span>
        delete p<span class="sy4">;</span>
    <span class="br0">}</span>
<span class="br0">}</span><span class="sy4">;</span>
 
<span class="kw1">template</span><span class="sy1">&lt;&gt;</span>
<span class="kw4">int</span> A<span class="sy1">&lt;</span>P<span class="sy1">&gt;</span><span class="sy4">::</span><span class="me2">sn</span> <span class="sy1">=</span> <span class="nu0">2</span><span class="sy4">;</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    A<span class="sy1">&lt;</span>P<span class="sy1">&gt;</span> a<span class="br0">(</span><span class="nu0">1</span><span class="br0">)</span><span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> a.<span class="me1">n</span> <span class="sy1">&lt;&lt;</span> <span class="st0">' '</span>
              <span class="sy1">&lt;&lt;</span> a.<span class="me1">sn</span> <span class="sy1">&lt;&lt;</span> <span class="st0">' '</span>   <span class="co1">// A::sn also works</span>
              <span class="sy1">&lt;&lt;</span> a.<span class="me1">f</span><span class="br0">(</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">' '</span> 
              <span class="sy1">&lt;&lt;</span> a.<span class="me1">sf</span><span class="br0">(</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">' '</span> <span class="co1">// A::sf() also works</span>
<span class="co1">//            &lt;&lt; a.B &lt;&lt; ' '    // error: nested type not allowed</span>
              <span class="sy1">&lt;&lt;</span> a.<span class="me1">RED</span> <span class="sy1">&lt;&lt;</span> <span class="st0">' '</span><span class="sy4">;</span> <span class="co1">// enumerator</span>
<span class="br0">}</span></pre></div></div>
<p>Output:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="text source-text"><pre class="de1">1 2 11 4 1</pre></div></div> 
</div>
<h4><span class="mw-headline" id="Built-in_pointer-to-member_access_operators">Built-in pointer-to-member access operators</span></h4>
<p>The member access operator expressions through pointers to members have the form 
</p>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">lhs</span> <code><b>.*</b></code> <span class="t-spar">rhs</span>
</td>
<td> (1)
</td>
<td class="t-sdsc-nopad">
</td></tr>

 

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">lhs</span> <code><b>-&gt;*</b></code> <span class="t-spar">rhs</span>
</td>
<td> (2)
</td>
<td class="t-sdsc-nopad">
</td></tr>

 

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr></table>
<div class="t-li1"><span class="t-li">1)</span> <span class="t-spar">lhs</span> must be an expression of class type <code>T</code>.</div>
<div class="t-li1"><span class="t-li">2)</span> <span class="t-spar">lhs</span> must be an expression of type pointer to class type <code>T*</code>.</div>
<p>The second operand of both operators is an expression of type pointer to member ( <a href="pointer.html#Pointers_to_data_members" title="cpp/language/pointer">data</a> or <a href="pointer.html#Pointers_to_member_functions" title="cpp/language/pointer">function</a>) of <code>T</code> or pointer to member of an unambiguous and accessible base class <code>B</code> of <code>T</code>.
</p><p>The expression <span class="t-c"><span class="mw-geshi cpp source-cpp">E1<span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span>E2</span></span> is exactly equivalent to <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="br0">(</span><span class="sy2">*</span>E1<span class="br0">)</span>.<span class="sy2">*</span>E2</span></span> for built-in types; that is why the following rules address only <span class="t-c"><span class="mw-geshi cpp source-cpp">E1.<span class="sy2">*</span>E2</span></span>.
</p><p>In the expression <span class="t-c"><span class="mw-geshi cpp source-cpp">E1.<span class="sy2">*</span>E2</span></span>:
</p>
<div class="t-li1"><span class="t-li">1)</span> if <code>E2</code> is a pointer to data member,
<ul><li> if <code>E1</code> is an lvalue, the result is an lvalue designating that data member,
</li><li> otherwise (if <code>E1</code> is an <span class="t-rev-inl t-until-cxx17"><span>rvalue</span> <span><span class="t-mark-rev t-until-cxx17">(until C++17)</span></span></span><span class="t-rev-inl t-since-cxx17"><span>xvalue (which may be <a href="implicit_cast.html#Temporary_materialization" title="cpp/language/implicit conversion">materialized</a> from prvalue)</span> <span><span class="t-mark-rev t-since-cxx17">(since C++17)</span></span></span>), the result is an <span class="t-rev-inl t-until-cxx11"><span>rvalue</span> <span><span class="t-mark-rev t-until-cxx11">(until C++11)</span></span></span><span class="t-rev-inl t-since-cxx11"><span>xvalue</span> <span><span class="t-mark-rev t-since-cxx11">(since C++11)</span></span></span> designating that data member;</li></ul></div>

<div class="t-li1"><span class="t-li">2)</span> if <code>E2</code> is a pointer to member function, the result is a special kind of prvalue designating that member function that can only be used as the left-hand operand of a member function call operator, and for no other purpose;</div>
<div class="t-li1"><span class="t-li">3)</span> cv-qualification rules are the same as for member of object operator, with one additional rule: a pointer to member that refers to a mutable member cannot be used to modify that member in a const object;</div>
<div class="t-li1"><span class="t-li">4)</span> if <code>E2</code> is a null pointer-to-member value, the behavior is undefined;</div>
<div class="t-li1"><span class="t-li">5)</span> if the <a href="type-id.html#Dynamic_type" title="cpp/language/type">dynamic type</a> of <code>E1</code> does not contain the member to which <code>E2</code> refers, the behavior is undefined;</div>
<div class="t-li1"><span class="t-li">6)</span> if <code>E1</code> is an rvalue and <code>E2</code> points to a member function with ref-qualifier &amp;, the program is ill-formed <span class="t-rev-inl t-since-cxx20"><span>unless the member function has the cv-qualifier <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">const</span></span></span> but not <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">volatile</span></span></span></span> <span><span class="t-mark-rev t-since-cxx20">(since C++20)</span></span></span>;</div>
<div class="t-li1"><span class="t-li">7)</span> if <code>E1</code> is an lvalue and <code>E2</code> points to a member function with ref-qualifier &amp;&amp;, the program is ill-formed.</div>
<p>In <a href="overload_resolution.html#Call_to_an_overloaded_operator" title="cpp/language/overload resolution">overload resolution against user-defined operators</a>, for every combination of types <code>D</code>, <code>B</code>, <code>R</code>, where class type <code>B</code> is either the same class as <code>D</code> or an unambiguous and accessible base class of <code>D</code>, and <code>R</code> is either an object or function type, the following function signature participates in overload resolution:
</p>
<table class="t-dcl-begin"><tbody>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">R<span class="sy3">&amp;</span> operator<span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span><span class="br0">(</span>D<span class="sy2">*</span>, R B<span class="sy4">::</span><span class="sy2">*</span><span class="br0">)</span><span class="sy4">;</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl-sep"><td></td><td></td><td></td></tr>
</tbody></table>
<p>where both operands may be cv-qualified, in which case the return type's cv-qualification is the union of the cv-qualification of the operands.
</p>
<div class="t-example"><div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;iostream&gt;</span>
 
<span class="kw1">struct</span> S
<span class="br0">{</span>
    S<span class="br0">(</span><span class="kw4">int</span> n<span class="br0">)</span><span class="sy4">:</span> mi<span class="br0">(</span>n<span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span>
    mutable <span class="kw4">int</span> mi<span class="sy4">;</span>
    <span class="kw4">int</span> f<span class="br0">(</span><span class="kw4">int</span> n<span class="br0">)</span> <span class="br0">{</span> <span class="kw1">return</span> mi <span class="sy2">+</span> n<span class="sy4">;</span> <span class="br0">}</span>
<span class="br0">}</span><span class="sy4">;</span>
 
<span class="kw1">struct</span> D<span class="sy4">:</span> <span class="kw1">public</span> S
<span class="br0">{</span>
    D<span class="br0">(</span><span class="kw4">int</span> n<span class="br0">)</span><span class="sy4">:</span> S<span class="br0">(</span>n<span class="br0">)</span> <span class="br0">{</span><span class="br0">}</span>
<span class="br0">}</span><span class="sy4">;</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    <span class="kw4">int</span> S<span class="sy4">::</span><span class="sy2">*</span> pmi <span class="sy1">=</span> <span class="sy3">&amp;</span>S<span class="sy4">::</span><span class="me2">mi</span><span class="sy4">;</span>
    <span class="kw4">int</span> <span class="br0">(</span>S<span class="sy4">::</span><span class="sy2">*</span> pf<span class="br0">)</span><span class="br0">(</span><span class="kw4">int</span><span class="br0">)</span> <span class="sy1">=</span> <span class="sy3">&amp;</span>S<span class="sy4">::</span><span class="me2">f</span><span class="sy4">;</span>
 
    <span class="kw4">const</span> S s<span class="br0">(</span><span class="nu0">7</span><span class="br0">)</span><span class="sy4">;</span>
<span class="co1">//  s.*pmi = 10; // error: cannot modify through mutable</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> s.<span class="sy2">*</span>pmi <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
 
    D d<span class="br0">(</span><span class="nu0">7</span><span class="br0">)</span><span class="sy4">;</span> <span class="co1">// base pointers work with derived object</span>
    D<span class="sy2">*</span> pd <span class="sy1">=</span> <span class="sy3">&amp;</span>d<span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> <span class="br0">(</span>d.<span class="sy2">*</span>pf<span class="br0">)</span><span class="br0">(</span><span class="nu0">7</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">' '</span>
              <span class="sy1">&lt;&lt;</span> <span class="br0">(</span>pd<span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span>pf<span class="br0">)</span><span class="br0">(</span><span class="nu0">8</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
<span class="br0">}</span></pre></div></div>
<p>Output:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="text source-text"><pre class="de1">7
14 15</pre></div></div> 
</div>
<h3><span class="mw-headline" id="Standard_library">Standard library</span></h3>
<p>Subscript operator is overloaded by many standard container classes
</p>
<table class="t-dsc-begin">

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../utility/bitset/operator_at.html" title="cpp/utility/bitset/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   accesses specific bit <br> <span class="t-mark">(public member function of <code>std::bitset&lt;N&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../memory/unique_ptr/operator_at.html" title="cpp/memory/unique ptr/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   provides indexed access to the managed array  <br> <span class="t-mark">(public member function of <code>std::unique_ptr&lt;T,Deleter&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../string/basic_string/operator_at.html" title="cpp/string/basic string/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   accesses the specified character <br> <span class="t-mark">(public member function of <code>std::basic_string&lt;CharT,Traits,Allocator&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../container/array/operator_at.html" title="cpp/container/array/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div><div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx11">(C++11)</span></span></span></div></div>
</td>
<td>   access  specified element  <br> <span class="t-mark">(public member function of <code>std::array&lt;T,N&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../container/deque/operator_at.html" title="cpp/container/deque/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   access  specified element  <br> <span class="t-mark">(public member function of <code>std::deque&lt;T,Allocator&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../container/vector/operator_at.html" title="cpp/container/vector/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   access  specified element  <br> <span class="t-mark">(public member function of <code>std::vector&lt;T,Allocator&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../container/map/operator_at.html" title="cpp/container/map/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   access or insert specified element  <br> <span class="t-mark">(public member function of <code>std::map&lt;Key,T,Compare,Allocator&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../container/unordered_map/operator_at.html" title="cpp/container/unordered map/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div><div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx11">(C++11)</span></span></span></div></div>
</td>
<td>   access or insert specified element  <br> <span class="t-mark">(public member function of <code>std::unordered_map&lt;Key,T,Hash,KeyEqual,Allocator&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/reverse_iterator/operator_at.html" title="cpp/iterator/reverse iterator/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   accesses an element by index <br> <span class="t-mark">(public member function of <code>std::reverse_iterator&lt;Iter&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/move_iterator/operator_at.html" title="cpp/iterator/move iterator/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div><div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx11">(C++11)</span></span></span></div></div>
</td>
<td>    accesses an element by index <br> <span class="t-mark">(public member function of <code>std::move_iterator&lt;Iter&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/valarray/operator_at.html" title="cpp/numeric/valarray/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   get/set valarray element, slice, or mask <br> <span class="t-mark">(public member function of <code>std::valarray&lt;T&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../regex/match_results/operator_at.html" title="cpp/regex/match results/operator at"> <span class="t-lines"><span>operator[]</span></span></a></div></div>
</td>
<td>   returns specified sub-match <br> <span class="t-mark">(public member function of <code>std::match_results&lt;BidirIt,Alloc&gt;</code>)</span> </td></tr>
</table>
<p>The indirection and member operators are overloaded by many iterators and smart pointer classes
</p>
<table class="t-dsc-begin">

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../memory/unique_ptr/operator_star_.html" title="cpp/memory/unique ptr/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   dereferences pointer to the managed object  <br> <span class="t-mark">(public member function of <code>std::unique_ptr&lt;T,Deleter&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../memory/shared_ptr/operator_star_.html" title="cpp/memory/shared ptr/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   dereferences the stored pointer <br> <span class="t-mark">(public member function of <code>std::shared_ptr&lt;T&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../memory/auto_ptr/operator_star_.html" title="cpp/memory/auto ptr/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   accesses the managed object <br> <span class="t-mark">(public member function of <code>std::auto_ptr&lt;T&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../memory/raw_storage_iterator/operator_star_.html" title="cpp/memory/raw storage iterator/operator*"> <span class="t-lines"><span>operator*</span></span></a></div></div>
</td>
<td>   dereferences the iterator <br> <span class="t-mark">(public member function of <code>std::raw_storage_iterator&lt;OutputIt,T&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/reverse_iterator/operator_star_.html" title="cpp/iterator/reverse iterator/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   dereferences the decremented underlying iterator <br> <span class="t-mark">(public member function of <code>std::reverse_iterator&lt;Iter&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/back_insert_iterator/operator_star_.html" title="cpp/iterator/back insert iterator/operator*"> <span class="t-lines"><span>operator*</span></span></a></div></div>
</td>
<td>   no-op  <br> <span class="t-mark">(public member function of <code>std::back_insert_iterator&lt;Container&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/front_insert_iterator/operator_star_.html" title="cpp/iterator/front insert iterator/operator*"> <span class="t-lines"><span>operator*</span></span></a></div></div>
</td>
<td>   no-op  <br> <span class="t-mark">(public member function of <code>std::front_insert_iterator&lt;Container&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/insert_iterator/operator_star_.html" title="cpp/iterator/insert iterator/operator*"> <span class="t-lines"><span>operator*</span></span></a></div></div>
</td>
<td>   no-op  <br> <span class="t-mark">(public member function of <code>std::insert_iterator&lt;Container&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/move_iterator/operator_star_.html" title="cpp/iterator/move iterator/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div><div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx11">(C++11)</span></span><span><span class="t-mark-rev t-since-cxx11">(C++11)</span><span class="t-mark-rev t-deprecated-cxx20">(deprecated in C++20)</span></span></span></div></div>
</td>
<td>   accesses the pointed-to element <br> <span class="t-mark">(public member function of <code>std::move_iterator&lt;Iter&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/istream_iterator/operator_star_.html" title="cpp/iterator/istream iterator/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   returns the current element <br> <span class="t-mark">(public member function of <code>std::istream_iterator&lt;T,CharT,Traits,Distance&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/ostream_iterator/operator_star_.html" title="cpp/iterator/ostream iterator/operator*"> <span class="t-lines"><span>operator*</span></span></a></div></div>
</td>
<td>   no-op  <br> <span class="t-mark">(public member function of <code>std::ostream_iterator&lt;T,CharT,Traits&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/istreambuf_iterator/operator_star_.html" title="cpp/iterator/istreambuf iterator/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div><div><span class="t-lines"><span></span><span><span class="t-mark-rev t-since-cxx11">(since C++11)</span><span class="t-mark-rev t-until-cxx17">(until C++17)</span></span></span></div></div>
</td>
<td>   obtains a copy of the current character<br>accesses a member of the current character, if <code>CharT</code> has members  <br> <span class="t-mark">(public member function of <code>std::istreambuf_iterator&lt;CharT,Traits&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/ostreambuf_iterator/operator_star_.html" title="cpp/iterator/ostreambuf iterator/operator*"> <span class="t-lines"><span>operator*</span></span></a></div></div>
</td>
<td>   no-op  <br> <span class="t-mark">(public member function of <code>std::ostreambuf_iterator&lt;CharT,Traits&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../regex/regex_iterator/operator_star_.html" title="cpp/regex/regex iterator/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   accesses the current match <br> <span class="t-mark">(public member function of <code>std::regex_iterator&lt;BidirIt,CharT,Traits&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../regex/regex_token_iterator/operator_star_.html" title="cpp/regex/regex token iterator/operator*"> <span class="t-lines"><span>operator*</span><span>operator-&gt;</span></span></a></div></div>
</td>
<td>   accesses current submatch <br> <span class="t-mark">(public member function of <code>std::regex_token_iterator&lt;BidirIt,CharT,Traits&gt;</code>)</span> </td></tr>
</table>
<p>No standard library classes overload <span class="t-c"><span class="mw-geshi cpp source-cpp">operator<span class="sy3">&amp;</span></span></span>. The best known example of overloaded <span class="t-c"><span class="mw-geshi cpp source-cpp">operator<span class="sy3">&amp;</span></span></span> is the Microsoft COM class <a rel="nofollow" class="external text" href="http://msdn.microsoft.com/en-us/library/31k6d0k7(v=vs.100).aspx"><code>CComPtr</code></a>, although it can also appear in EDSLs such as <a rel="nofollow" class="external text" href="http://www.boost.org/doc/libs/release/libs/spirit/doc/html/spirit/qi/reference/operator/and_predicate.html">boost.spirit</a>
</p><p>No standard library classes overload <span class="t-c"><span class="mw-geshi cpp source-cpp">operator<span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span></span></span>. It was suggested that it could be part of <a rel="nofollow" class="external text" href="http://www.aristeia.com/Papers/DDJ_Oct_1999.pdf">smart pointer interface</a>, and in fact is used in that capacity by actors in <a rel="nofollow" class="external text" href="http://www.boost.org/doc/libs/release/libs/phoenix/doc/html/phoenix/modules/operator.html#phoenix.modules.operator.member_pointer_operator">boost.phoenix</a>, but is more common in EDSLs such as <a rel="nofollow" class="external text" href="https://github.com/schlangster/cpp.react/blob/master/include/react/Signal.h#L557">cpp.react</a>.
</p>
<h3><span class="mw-headline" id="Defect_reports">Defect reports</span></h3>
<p>The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
</p>
<table class="dsctable" style="font-size:0.8em">
<tr>
<th> DR
</th>
<th> Applied to
</th>
<th> Behavior as published
</th>
<th> Correct behavior
</th></tr>
<tr>
<td> <a rel="nofollow" class="external text" href="https://cplusplus.github.io/CWG/issues/1213.html">CWG 1213</a>
</td>
<td> C++11
</td>
<td> subscripting an array rvalue resulted in  lvalue
</td>
<td> reclassified as xvalue
</td></tr>
<tr>
<td> <a rel="nofollow" class="external text" href="https://cplusplus.github.io/CWG/issues/1458.html">CWG 1458</a>
</td>
<td> C++98
</td>
<td> applying <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">&amp;</span></span></span> to an lvalue of incomplete class type which<br>declares <span class="t-c"><span class="mw-geshi cpp source-cpp">operator<span class="sy3">&amp;</span></span></span> resulted in undefined behavior
</td>
<td> it is unspecified<br>which <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">&amp;</span></span></span> is used
</td></tr>
<tr>
<td> <a rel="nofollow" class="external text" href="https://cplusplus.github.io/CWG/issues/1800.html">CWG 1800</a>
</td>
<td> C++98
</td>
<td> when applying <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">&amp;</span></span></span> to a non-static data member of a<br>member anonymous union, it was unclear whether<br>the anonymous union take a part in the result type
</td>
<td> the anonymous union<br>is not included in<br>the result type
</td></tr></table>
<h3><span class="mw-headline" id="See_also">See also</span></h3>
<p><a href="operator_precedence.html" title="cpp/language/operator precedence">Operator precedence</a>
</p><p><a href="operators.html" title="cpp/language/operators">Operator overloading</a>
</p>
<table class="wikitable">

<tr style="text-align:center">
<th colspan="7"> Common operators
</th></tr>
<tr style="text-align:center">
<td> <a href="operator_assignment.html" title="cpp/language/operator assignment"> assignment</a>
</td>
<td> <a href="operator_incdec.html" title="cpp/language/operator incdec"> increment<br>decrement</a>
</td>
<td> <a href="operator_arithmetic.html" title="cpp/language/operator arithmetic"> arithmetic</a>
</td>
<td> <a href="operator_logical.html" title="cpp/language/operator logical"> logical</a>
</td>
<td> <a href="operator_comparison.html" title="cpp/language/operator comparison"> comparison</a>
</td>
<td> <strong class="selflink"> member<br>access</strong>
</td>
<td> <a href="operator_other.html" title="cpp/language/operator other"> other</a>
</td></tr>
<tr style="text-align:center">
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">=</span> b<br>
a <span class="sy2">+</span><span class="sy1">=</span> b<br>
a <span class="sy2">-</span><span class="sy1">=</span> b<br>
a <span class="sy2">*</span><span class="sy1">=</span> b<br>
a <span class="sy2">/</span><span class="sy1">=</span> b<br>
a <span class="sy2">%</span><span class="sy1">=</span> b<br>
a <span class="sy3">&amp;</span><span class="sy1">=</span> b<br>
a <span class="sy3">|</span><span class="sy1">=</span> b<br>
a <span class="sy3">^</span><span class="sy1">=</span> b<br>
a <span class="sy1">&lt;&lt;=</span> b<br>
a <span class="sy1">&gt;&gt;=</span> b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy2">++</span>a<br>
<span class="sy2">--</span>a<br>
a<span class="sy2">++</span><br>
a<span class="sy2">--</span></span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy2">+</span>a<br>
<span class="sy2">-</span>a<br>
a <span class="sy2">+</span> b<br>
a <span class="sy2">-</span> b<br>
a <span class="sy2">*</span> b<br>
a <span class="sy2">/</span> b<br>
a <span class="sy2">%</span> b<br>
~a<br>
a <span class="sy3">&amp;</span> b<br>
a <span class="sy3">|</span> b<br>
a <span class="sy3">^</span> b<br>
a <span class="sy1">&lt;&lt;</span> b<br>
a <span class="sy1">&gt;&gt;</span> b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">!</span>a<br>
a <span class="sy3">&amp;&amp;</span> b<br>
a <span class="sy3">||</span> b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">==</span> b<br>
a <span class="sy3">!</span><span class="sy1">=</span> b<br>
a <span class="sy1">&lt;</span> b<br>
a <span class="sy1">&gt;</span> b<br>
a <span class="sy1">&lt;=</span> b<br>
a <span class="sy1">&gt;=</span> b<br>
a <span class="sy1">&lt;=&gt;</span> b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp">a<span class="br0">[</span>b<span class="br0">]</span><br>
<span class="sy2">*</span>a<br>
<span class="sy3">&amp;</span>a<br>
a<span class="sy2">-</span><span class="sy1">&gt;</span>b<br>
a.<span class="me1">b</span><br>
a<span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span>b<br>
a.<span class="sy2">*</span>b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp">a<span class="br0">(</span>...<span class="br0">)</span><br>
a, b<br>
a <span class="sy4">?</span> b <span class="sy4">:</span> c</span></span>
</p>
</td></tr>
<tr>
<th colspan="7"> Special operators
</th></tr>
<tr>
<td colspan="7">
<p><a href="static_cast.html" title="cpp/language/static cast"><tt>static_cast</tt></a> converts one type to another related type <br>
<a href="dynamic_cast.html" title="cpp/language/dynamic cast"><tt>dynamic_cast</tt></a> converts within inheritance hierarchies <br>
<a href="const_cast.html" title="cpp/language/const cast"><tt>const_cast</tt></a> adds or removes <a href="cv.html" title="cpp/language/cv">cv</a> qualifiers<br>
<a href="reinterpret_cast.html" title="cpp/language/reinterpret cast"><tt>reinterpret_cast</tt></a> converts type to unrelated type<br>
<a href="explicit_cast.html" title="cpp/language/explicit cast">C-style cast</a> converts one type to another by a mix of <code>static_cast</code>, <code>const_cast</code>, and <code>reinterpret_cast</code> <br>
<a href="new.html" title="cpp/language/new"><tt>new</tt></a> creates objects with dynamic storage duration<br>
<a href="delete.html" title="cpp/language/delete"><tt>delete</tt></a> destructs objects previously created by the new expression and releases obtained memory area<br>
<a href="sizeof.html" title="cpp/language/sizeof"><tt>sizeof</tt></a> queries the size of a type<br>
<a href="sizeof....html" title="cpp/language/sizeof..."><tt>sizeof...</tt></a> queries the size of a <a href="parameter_pack.html" title="cpp/language/parameter pack">parameter pack</a> <span class="t-mark-rev t-since-cxx11">(since C++11)</span><br>
<a href="typeid.html" title="cpp/language/typeid"><tt>typeid</tt></a> queries the type information of a type<br>
<a href="noexcept.html" title="cpp/language/noexcept"><tt>noexcept</tt></a> checks if an expression can throw an exception <span class="t-mark-rev t-since-cxx11">(since C++11)</span><br>
<a href="alignof.html" title="cpp/language/alignof"><tt>alignof</tt></a> queries alignment requirements of a type <span class="t-mark-rev t-since-cxx11">(since C++11)</span>
</p>
</td></tr></table>
<table class="t-dsc-begin">

</table>

<!-- 
NewPP limit report
Preprocessor visited node count: 13604/1000000
Preprocessor generated node count: 21424/1000000
Post‐expand include size: 346074/2097152 bytes
Template argument size: 76168/2097152 bytes
Highest expansion depth: 32/40
Expensive parser function count: 0/100
-->

<!-- Saved in parser cache with key mwiki1-mwiki_en_:pcache:idhash:707-0!*!0!!en!*!* and timestamp 20220614071808 -->
</div>                    <!-- /bodycontent -->
                                        <!-- printfooter -->
                    <div class="printfooter">
                    Retrieved from "<a href="https://en.cppreference.com/mwiki/index.php?title=cpp/language/operator_member_access&amp;oldid=140248">https://en.cppreference.com/mwiki/index.php?title=cpp/language/operator_member_access&amp;oldid=140248</a>"                    </div>
                    <!-- /printfooter -->
                                                            <!-- catlinks -->
                    <!-- /catlinks -->
                                                            <div class="visualClear"></div>
                    <!-- debughtml -->
                                        <!-- /debughtml -->
                </div>
                <!-- /bodyContent -->
            </div>
        </div>
        <!-- /content -->
        <!-- footer -->
        <div id="cpp-footer-base" class="noprint">
            <div id="footer">
                        <div id="cpp-navigation">
            <h5>Navigation</h5>
            <ul><li><a href="https://en.cppreference.com/w/cpp/language/operator_member_access">Online version</a></li><li>Offline version retrieved 2022-07-30 14:05.</li></ul></div>
                        <ul id="footer-info">
                                    <li id="footer-info-lastmod"> This page was last modified on 14 June 2022, at 00:18.</li>
                                    <li id="footer-info-viewcount">This page has been accessed 378,530 times.</li>
                            </ul>
                    </div>
        </div>
        <!-- /footer -->
        <script>if(window.mw){
mw.loader.state({"site":"loading","user":"missing","user.groups":"ready"});
}</script>
<script src="../../../common/skin_scripts.js"></script>
<script>if(window.mw){
mw.loader.load(["mediawiki.action.view.postEdit","mediawiki.user","mediawiki.page.ready","mediawiki.searchSuggest","mediawiki.hidpi","ext.gadget.ColiruCompiler","ext.gadget.MathJax"], null, true);
}</script>
<script src="../../../common/site_scripts.js"></script>
<script type="text/javascript">
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-2828341-1']);
_gaq.push(['_setDomainName', 'cppreference.com']);
_gaq.push(['_trackPageview']);
</script><!-- Served in 0.034 secs. -->
	</body>
<!-- Cached 20220614071908 -->
</html>